// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.sourcing.manage;

import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class SourcingManageSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SourcingManage".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("taskId", "dt");
    map.put("sourcingPersonnel", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：SourcingManage/AllData, SourcingManage/Receive, SourcingManage/Complete, SourcingManage/NoIncomplete, SourcingManage/Expired
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 开发任务编号
   */
  private Long taskId;

  /**
   * 开发任务编号 比较(eq)
   */
  private Long taskIdEq;
  /**
   * 开发任务编号 比较(neq)
   */
  private Long taskIdNeq;
  /**
   * 开发任务编号 比较(gt)
   */
  private Long taskIdGt;
  /**
   * 开发任务编号 比较(gte)
   */
  private Long taskIdGte;
  /**
   * 开发任务编号 比较(lt)
   */
  private Long taskIdLt;
  /**
   * 开发任务编号 比较(lte)
   */
  private Long taskIdLte;
  /**
   * 开发任务编号 比较(contains)
   */
  private Long taskIdContains;
  /**
   * 开发任务编号 比较(notcontains)
   */
  private Long taskIdNotcontains;
  /**
   * 开发任务编号 比较(startswith)
   */
  private Long taskIdStartswith;
  /**
   * 开发任务编号 比较(endswith)
   */
  private Long taskIdEndswith;
  /**
   * 开发任务编号 比较(isnull)
   */
  private Boolean taskIdIsnull;
  /**
   * 开发任务编号 比较(isnotnull)
   */
  private Boolean taskIdIsnotnull;
  /**
   * 开发任务编号的任务编号 比较(eq)
   */
  private String taskIdTaskIdEq;
  /**
   * 开发任务编号的任务编号 比较(neq)
   */
  private String taskIdTaskIdNeq;
  /**
   * 开发任务编号的任务编号 比较(gt)
   */
  private String taskIdTaskIdGt;
  /**
   * 开发任务编号的任务编号 比较(gte)
   */
  private String taskIdTaskIdGte;
  /**
   * 开发任务编号的任务编号 比较(lt)
   */
  private String taskIdTaskIdLt;
  /**
   * 开发任务编号的任务编号 比较(lte)
   */
  private String taskIdTaskIdLte;
  /**
   * 开发任务编号的任务编号 比较(contains)
   */
  private String taskIdTaskIdContains;
  /**
   * 开发任务编号的任务编号 比较(notcontains)
   */
  private String taskIdTaskIdNotcontains;
  /**
   * 开发任务编号的任务编号 比较(startswith)
   */
  private String taskIdTaskIdStartswith;
  /**
   * 开发任务编号的任务编号 比较(endswith)
   */
  private String taskIdTaskIdEndswith;
  /**
   * 开发任务编号的任务编号 比较(isnull)
   */
  private Boolean taskIdTaskIdIsnull;
  /**
   * 开发任务编号的任务编号 比较(isnotnull)
   */
  private Boolean taskIdTaskIdIsnotnull;

  /**
   * 开发任务编号(范围搜索)
   */
  private List<Long> taskIdInList;

  /**
   * 最早寻源时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date sourcingTimeStart;

  /**
   * 最晚寻源时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date sourcingTimeEnd;

  /**
   * 寻源时间 比较(eq)
   */
  private Date sourcingTimeEq;
  /**
   * 寻源时间 比较(neq)
   */
  private Date sourcingTimeNeq;
  /**
   * 寻源时间 比较(gt)
   */
  private Date sourcingTimeGt;
  /**
   * 寻源时间 比较(gte)
   */
  private Date sourcingTimeGte;
  /**
   * 寻源时间 比较(lt)
   */
  private Date sourcingTimeLt;
  /**
   * 寻源时间 比较(lte)
   */
  private Date sourcingTimeLte;
  /**
   * 寻源时间 比较(contains)
   */
  private Date sourcingTimeContains;
  /**
   * 寻源时间 比较(notcontains)
   */
  private Date sourcingTimeNotcontains;
  /**
   * 寻源时间 比较(startswith)
   */
  private Date sourcingTimeStartswith;
  /**
   * 寻源时间 比较(endswith)
   */
  private Date sourcingTimeEndswith;
  /**
   * 寻源时间 比较(isnull)
   */
  private Boolean sourcingTimeIsnull;
  /**
   * 寻源时间 比较(isnotnull)
   */
  private Boolean sourcingTimeIsnotnull;

  /**
   * 寻源人员
   */
  private Long sourcingPersonnel;

  /**
   * 寻源人员 比较(eq)
   */
  private Long sourcingPersonnelEq;
  /**
   * 寻源人员 比较(neq)
   */
  private Long sourcingPersonnelNeq;
  /**
   * 寻源人员 比较(gt)
   */
  private Long sourcingPersonnelGt;
  /**
   * 寻源人员 比较(gte)
   */
  private Long sourcingPersonnelGte;
  /**
   * 寻源人员 比较(lt)
   */
  private Long sourcingPersonnelLt;
  /**
   * 寻源人员 比较(lte)
   */
  private Long sourcingPersonnelLte;
  /**
   * 寻源人员 比较(contains)
   */
  private Long sourcingPersonnelContains;
  /**
   * 寻源人员 比较(notcontains)
   */
  private Long sourcingPersonnelNotcontains;
  /**
   * 寻源人员 比较(startswith)
   */
  private Long sourcingPersonnelStartswith;
  /**
   * 寻源人员 比较(endswith)
   */
  private Long sourcingPersonnelEndswith;
  /**
   * 寻源人员 比较(isnull)
   */
  private Boolean sourcingPersonnelIsnull;
  /**
   * 寻源人员 比较(isnotnull)
   */
  private Boolean sourcingPersonnelIsnotnull;
  /**
   * 寻源人员的显示用户名 比较(eq)
   */
  private String sourcingPersonnelNameEq;
  /**
   * 寻源人员的显示用户名 比较(neq)
   */
  private String sourcingPersonnelNameNeq;
  /**
   * 寻源人员的显示用户名 比较(gt)
   */
  private String sourcingPersonnelNameGt;
  /**
   * 寻源人员的显示用户名 比较(gte)
   */
  private String sourcingPersonnelNameGte;
  /**
   * 寻源人员的显示用户名 比较(lt)
   */
  private String sourcingPersonnelNameLt;
  /**
   * 寻源人员的显示用户名 比较(lte)
   */
  private String sourcingPersonnelNameLte;
  /**
   * 寻源人员的显示用户名 比较(contains)
   */
  private String sourcingPersonnelNameContains;
  /**
   * 寻源人员的显示用户名 比较(notcontains)
   */
  private String sourcingPersonnelNameNotcontains;
  /**
   * 寻源人员的显示用户名 比较(startswith)
   */
  private String sourcingPersonnelNameStartswith;
  /**
   * 寻源人员的显示用户名 比较(endswith)
   */
  private String sourcingPersonnelNameEndswith;
  /**
   * 寻源人员的显示用户名 比较(isnull)
   */
  private Boolean sourcingPersonnelNameIsnull;
  /**
   * 寻源人员的显示用户名 比较(isnotnull)
   */
  private Boolean sourcingPersonnelNameIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 经销商分类
   */
  private String dealerClassification;

  /**
   * 经销商分类 比较(eq)
   */
  private String dealerClassificationEq;
  /**
   * 经销商分类 比较(neq)
   */
  private String dealerClassificationNeq;
  /**
   * 经销商分类 比较(gt)
   */
  private String dealerClassificationGt;
  /**
   * 经销商分类 比较(gte)
   */
  private String dealerClassificationGte;
  /**
   * 经销商分类 比较(lt)
   */
  private String dealerClassificationLt;
  /**
   * 经销商分类 比较(lte)
   */
  private String dealerClassificationLte;
  /**
   * 经销商分类 比较(contains)
   */
  private String dealerClassificationContains;
  /**
   * 经销商分类 比较(notcontains)
   */
  private String dealerClassificationNotcontains;
  /**
   * 经销商分类 比较(startswith)
   */
  private String dealerClassificationStartswith;
  /**
   * 经销商分类 比较(endswith)
   */
  private String dealerClassificationEndswith;
  /**
   * 经销商分类 比较(isnull)
   */
  private Boolean dealerClassificationIsnull;
  /**
   * 经销商分类 比较(isnotnull)
   */
  private Boolean dealerClassificationIsnotnull;

  /**
   * 经销商分类(精确搜索)
   */
  private List<String> dealerClassificationInList;

  /**
   * 未完成原因(模糊搜索)
   */
  private String incompleteCompletionReason;

  /**
   * 未完成原因 比较(eq)
   */
  private String incompleteCompletionReasonEq;
  /**
   * 未完成原因 比较(neq)
   */
  private String incompleteCompletionReasonNeq;
  /**
   * 未完成原因 比较(gt)
   */
  private String incompleteCompletionReasonGt;
  /**
   * 未完成原因 比较(gte)
   */
  private String incompleteCompletionReasonGte;
  /**
   * 未完成原因 比较(lt)
   */
  private String incompleteCompletionReasonLt;
  /**
   * 未完成原因 比较(lte)
   */
  private String incompleteCompletionReasonLte;
  /**
   * 未完成原因 比较(contains)
   */
  private String incompleteCompletionReasonContains;
  /**
   * 未完成原因 比较(notcontains)
   */
  private String incompleteCompletionReasonNotcontains;
  /**
   * 未完成原因 比较(startswith)
   */
  private String incompleteCompletionReasonStartswith;
  /**
   * 未完成原因 比较(endswith)
   */
  private String incompleteCompletionReasonEndswith;
  /**
   * 未完成原因 比较(isnull)
   */
  private Boolean incompleteCompletionReasonIsnull;
  /**
   * 未完成原因 比较(isnotnull)
   */
  private Boolean incompleteCompletionReasonIsnotnull;

  /**
   * 未完成原因(精确搜索)
   */
  private List<String> incompleteCompletionReasonInList;

  /**
   * 状态
   */
  private String state;

  /**
   * 状态 比较(eq)
   */
  private String stateEq;
  /**
   * 状态 比较(neq)
   */
  private String stateNeq;
  /**
   * 状态 比较(gt)
   */
  private String stateGt;
  /**
   * 状态 比较(gte)
   */
  private String stateGte;
  /**
   * 状态 比较(lt)
   */
  private String stateLt;
  /**
   * 状态 比较(lte)
   */
  private String stateLte;
  /**
   * 状态 比较(contains)
   */
  private String stateContains;
  /**
   * 状态 比较(notcontains)
   */
  private String stateNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String stateStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String stateEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean stateIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean stateIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> stateInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 工牌胸卡
   */
  private Long workBadge;

  /**
   * 最小工牌胸卡
   */
  private Long workBadgeMin;

  /**
   * 最大工牌胸卡
   */
  private Long workBadgeMax;

  /**
   * 工牌胸卡 比较(eq)
   */
  private Long workBadgeEq;
  /**
   * 工牌胸卡 比较(neq)
   */
  private Long workBadgeNeq;
  /**
   * 工牌胸卡 比较(gt)
   */
  private Long workBadgeGt;
  /**
   * 工牌胸卡 比较(gte)
   */
  private Long workBadgeGte;
  /**
   * 工牌胸卡 比较(lt)
   */
  private Long workBadgeLt;
  /**
   * 工牌胸卡 比较(lte)
   */
  private Long workBadgeLte;
  /**
   * 工牌胸卡 比较(contains)
   */
  private Long workBadgeContains;
  /**
   * 工牌胸卡 比较(notcontains)
   */
  private Long workBadgeNotcontains;
  /**
   * 工牌胸卡 比较(startswith)
   */
  private Long workBadgeStartswith;
  /**
   * 工牌胸卡 比较(endswith)
   */
  private Long workBadgeEndswith;
  /**
   * 工牌胸卡 比较(isnull)
   */
  private Boolean workBadgeIsnull;
  /**
   * 工牌胸卡 比较(isnotnull)
   */
  private Boolean workBadgeIsnotnull;

  /**
   * 经销商行业(模糊搜索)
   */
  private String dealerIndustry;

  /**
   * 经销商行业 比较(eq)
   */
  private String dealerIndustryEq;
  /**
   * 经销商行业 比较(neq)
   */
  private String dealerIndustryNeq;
  /**
   * 经销商行业 比较(gt)
   */
  private String dealerIndustryGt;
  /**
   * 经销商行业 比较(gte)
   */
  private String dealerIndustryGte;
  /**
   * 经销商行业 比较(lt)
   */
  private String dealerIndustryLt;
  /**
   * 经销商行业 比较(lte)
   */
  private String dealerIndustryLte;
  /**
   * 经销商行业 比较(contains)
   */
  private String dealerIndustryContains;
  /**
   * 经销商行业 比较(notcontains)
   */
  private String dealerIndustryNotcontains;
  /**
   * 经销商行业 比较(startswith)
   */
  private String dealerIndustryStartswith;
  /**
   * 经销商行业 比较(endswith)
   */
  private String dealerIndustryEndswith;
  /**
   * 经销商行业 比较(isnull)
   */
  private Boolean dealerIndustryIsnull;
  /**
   * 经销商行业 比较(isnotnull)
   */
  private Boolean dealerIndustryIsnotnull;

  /**
   * 经销商行业(精确搜索)
   */
  private List<String> dealerIndustryInList;

  /**
   * 编号
   */
  private Long enterpriseId;

  /**
   * 最小编号
   */
  private Long enterpriseIdMin;

  /**
   * 最大编号
   */
  private Long enterpriseIdMax;

  /**
   * 编号 比较(eq)
   */
  private Long enterpriseIdEq;
  /**
   * 编号 比较(neq)
   */
  private Long enterpriseIdNeq;
  /**
   * 编号 比较(gt)
   */
  private Long enterpriseIdGt;
  /**
   * 编号 比较(gte)
   */
  private Long enterpriseIdGte;
  /**
   * 编号 比较(lt)
   */
  private Long enterpriseIdLt;
  /**
   * 编号 比较(lte)
   */
  private Long enterpriseIdLte;
  /**
   * 编号 比较(contains)
   */
  private Long enterpriseIdContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long enterpriseIdNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long enterpriseIdStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long enterpriseIdEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean enterpriseIdIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean enterpriseIdIsnotnull;

  /**
   * 企业简称(模糊搜索)
   */
  private String enterpriseAbbreviation;

  /**
   * 企业简称 比较(eq)
   */
  private String enterpriseAbbreviationEq;
  /**
   * 企业简称 比较(neq)
   */
  private String enterpriseAbbreviationNeq;
  /**
   * 企业简称 比较(gt)
   */
  private String enterpriseAbbreviationGt;
  /**
   * 企业简称 比较(gte)
   */
  private String enterpriseAbbreviationGte;
  /**
   * 企业简称 比较(lt)
   */
  private String enterpriseAbbreviationLt;
  /**
   * 企业简称 比较(lte)
   */
  private String enterpriseAbbreviationLte;
  /**
   * 企业简称 比较(contains)
   */
  private String enterpriseAbbreviationContains;
  /**
   * 企业简称 比较(notcontains)
   */
  private String enterpriseAbbreviationNotcontains;
  /**
   * 企业简称 比较(startswith)
   */
  private String enterpriseAbbreviationStartswith;
  /**
   * 企业简称 比较(endswith)
   */
  private String enterpriseAbbreviationEndswith;
  /**
   * 企业简称 比较(isnull)
   */
  private Boolean enterpriseAbbreviationIsnull;
  /**
   * 企业简称 比较(isnotnull)
   */
  private Boolean enterpriseAbbreviationIsnotnull;

  /**
   * 企业简称(精确搜索)
   */
  private List<String> enterpriseAbbreviationInList;

  /**
   * 企业名称(模糊搜索)
   */
  private String enterpriseName;

  /**
   * 企业名称 比较(eq)
   */
  private String enterpriseNameEq;
  /**
   * 企业名称 比较(neq)
   */
  private String enterpriseNameNeq;
  /**
   * 企业名称 比较(gt)
   */
  private String enterpriseNameGt;
  /**
   * 企业名称 比较(gte)
   */
  private String enterpriseNameGte;
  /**
   * 企业名称 比较(lt)
   */
  private String enterpriseNameLt;
  /**
   * 企业名称 比较(lte)
   */
  private String enterpriseNameLte;
  /**
   * 企业名称 比较(contains)
   */
  private String enterpriseNameContains;
  /**
   * 企业名称 比较(notcontains)
   */
  private String enterpriseNameNotcontains;
  /**
   * 企业名称 比较(startswith)
   */
  private String enterpriseNameStartswith;
  /**
   * 企业名称 比较(endswith)
   */
  private String enterpriseNameEndswith;
  /**
   * 企业名称 比较(isnull)
   */
  private Boolean enterpriseNameIsnull;
  /**
   * 企业名称 比较(isnotnull)
   */
  private Boolean enterpriseNameIsnotnull;

  /**
   * 企业名称(精确搜索)
   */
  private List<String> enterpriseNameInList;

  /**
   * 社会信用代码
   */
  private Long socialCreditCode;

  /**
   * 最小社会信用代码
   */
  private Long socialCreditCodeMin;

  /**
   * 最大社会信用代码
   */
  private Long socialCreditCodeMax;

  /**
   * 社会信用代码 比较(eq)
   */
  private Long socialCreditCodeEq;
  /**
   * 社会信用代码 比较(neq)
   */
  private Long socialCreditCodeNeq;
  /**
   * 社会信用代码 比较(gt)
   */
  private Long socialCreditCodeGt;
  /**
   * 社会信用代码 比较(gte)
   */
  private Long socialCreditCodeGte;
  /**
   * 社会信用代码 比较(lt)
   */
  private Long socialCreditCodeLt;
  /**
   * 社会信用代码 比较(lte)
   */
  private Long socialCreditCodeLte;
  /**
   * 社会信用代码 比较(contains)
   */
  private Long socialCreditCodeContains;
  /**
   * 社会信用代码 比较(notcontains)
   */
  private Long socialCreditCodeNotcontains;
  /**
   * 社会信用代码 比较(startswith)
   */
  private Long socialCreditCodeStartswith;
  /**
   * 社会信用代码 比较(endswith)
   */
  private Long socialCreditCodeEndswith;
  /**
   * 社会信用代码 比较(isnull)
   */
  private Boolean socialCreditCodeIsnull;
  /**
   * 社会信用代码 比较(isnotnull)
   */
  private Boolean socialCreditCodeIsnotnull;

  /**
   * 注册资本
   */
  private Long registeredCapital;

  /**
   * 最小注册资本
   */
  private Long registeredCapitalMin;

  /**
   * 最大注册资本
   */
  private Long registeredCapitalMax;

  /**
   * 注册资本 比较(eq)
   */
  private Long registeredCapitalEq;
  /**
   * 注册资本 比较(neq)
   */
  private Long registeredCapitalNeq;
  /**
   * 注册资本 比较(gt)
   */
  private Long registeredCapitalGt;
  /**
   * 注册资本 比较(gte)
   */
  private Long registeredCapitalGte;
  /**
   * 注册资本 比较(lt)
   */
  private Long registeredCapitalLt;
  /**
   * 注册资本 比较(lte)
   */
  private Long registeredCapitalLte;
  /**
   * 注册资本 比较(contains)
   */
  private Long registeredCapitalContains;
  /**
   * 注册资本 比较(notcontains)
   */
  private Long registeredCapitalNotcontains;
  /**
   * 注册资本 比较(startswith)
   */
  private Long registeredCapitalStartswith;
  /**
   * 注册资本 比较(endswith)
   */
  private Long registeredCapitalEndswith;
  /**
   * 注册资本 比较(isnull)
   */
  private Boolean registeredCapitalIsnull;
  /**
   * 注册资本 比较(isnotnull)
   */
  private Boolean registeredCapitalIsnotnull;

  /**
   * 经营范围(模糊搜索)
   */
  private String businessScope;

  /**
   * 经营范围 比较(eq)
   */
  private String businessScopeEq;
  /**
   * 经营范围 比较(neq)
   */
  private String businessScopeNeq;
  /**
   * 经营范围 比较(gt)
   */
  private String businessScopeGt;
  /**
   * 经营范围 比较(gte)
   */
  private String businessScopeGte;
  /**
   * 经营范围 比较(lt)
   */
  private String businessScopeLt;
  /**
   * 经营范围 比较(lte)
   */
  private String businessScopeLte;
  /**
   * 经营范围 比较(contains)
   */
  private String businessScopeContains;
  /**
   * 经营范围 比较(notcontains)
   */
  private String businessScopeNotcontains;
  /**
   * 经营范围 比较(startswith)
   */
  private String businessScopeStartswith;
  /**
   * 经营范围 比较(endswith)
   */
  private String businessScopeEndswith;
  /**
   * 经营范围 比较(isnull)
   */
  private Boolean businessScopeIsnull;
  /**
   * 经营范围 比较(isnotnull)
   */
  private Boolean businessScopeIsnotnull;

  /**
   * 经营范围(精确搜索)
   */
  private List<String> businessScopeInList;

  /**
   * 地点(模糊搜索)
   */
  private String address;

  /**
   * 地点 比较(eq)
   */
  private String addressEq;
  /**
   * 地点 比较(neq)
   */
  private String addressNeq;
  /**
   * 地点 比较(gt)
   */
  private String addressGt;
  /**
   * 地点 比较(gte)
   */
  private String addressGte;
  /**
   * 地点 比较(lt)
   */
  private String addressLt;
  /**
   * 地点 比较(lte)
   */
  private String addressLte;
  /**
   * 地点 比较(contains)
   */
  private String addressContains;
  /**
   * 地点 比较(notcontains)
   */
  private String addressNotcontains;
  /**
   * 地点 比较(startswith)
   */
  private String addressStartswith;
  /**
   * 地点 比较(endswith)
   */
  private String addressEndswith;
  /**
   * 地点 比较(isnull)
   */
  private Boolean addressIsnull;
  /**
   * 地点 比较(isnotnull)
   */
  private Boolean addressIsnotnull;

  /**
   * 地点(精确搜索)
   */
  private List<String> addressInList;

  /**
   * 是否源头工厂
   */
  private Boolean ifSourceFactory;

  /**
   * 是否源头工厂
   */
  private String ifSourceFactoryEq;

  /**
   * 设计人员(模糊搜索)
   */
  private String designers;

  /**
   * 设计人员 比较(eq)
   */
  private String designersEq;
  /**
   * 设计人员 比较(neq)
   */
  private String designersNeq;
  /**
   * 设计人员 比较(gt)
   */
  private String designersGt;
  /**
   * 设计人员 比较(gte)
   */
  private String designersGte;
  /**
   * 设计人员 比较(lt)
   */
  private String designersLt;
  /**
   * 设计人员 比较(lte)
   */
  private String designersLte;
  /**
   * 设计人员 比较(contains)
   */
  private String designersContains;
  /**
   * 设计人员 比较(notcontains)
   */
  private String designersNotcontains;
  /**
   * 设计人员 比较(startswith)
   */
  private String designersStartswith;
  /**
   * 设计人员 比较(endswith)
   */
  private String designersEndswith;
  /**
   * 设计人员 比较(isnull)
   */
  private Boolean designersIsnull;
  /**
   * 设计人员 比较(isnotnull)
   */
  private Boolean designersIsnotnull;

  /**
   * 设计人员(精确搜索)
   */
  private List<String> designersInList;

  /**
   * 打版师(模糊搜索)
   */
  private String typesetter;

  /**
   * 打版师 比较(eq)
   */
  private String typesetterEq;
  /**
   * 打版师 比较(neq)
   */
  private String typesetterNeq;
  /**
   * 打版师 比较(gt)
   */
  private String typesetterGt;
  /**
   * 打版师 比较(gte)
   */
  private String typesetterGte;
  /**
   * 打版师 比较(lt)
   */
  private String typesetterLt;
  /**
   * 打版师 比较(lte)
   */
  private String typesetterLte;
  /**
   * 打版师 比较(contains)
   */
  private String typesetterContains;
  /**
   * 打版师 比较(notcontains)
   */
  private String typesetterNotcontains;
  /**
   * 打版师 比较(startswith)
   */
  private String typesetterStartswith;
  /**
   * 打版师 比较(endswith)
   */
  private String typesetterEndswith;
  /**
   * 打版师 比较(isnull)
   */
  private Boolean typesetterIsnull;
  /**
   * 打版师 比较(isnotnull)
   */
  private Boolean typesetterIsnotnull;

  /**
   * 打版师(精确搜索)
   */
  private List<String> typesetterInList;

  /**
   * 排产人员(模糊搜索)
   */
  private String productionSchedulingPersonnel;

  /**
   * 排产人员 比较(eq)
   */
  private String productionSchedulingPersonnelEq;
  /**
   * 排产人员 比较(neq)
   */
  private String productionSchedulingPersonnelNeq;
  /**
   * 排产人员 比较(gt)
   */
  private String productionSchedulingPersonnelGt;
  /**
   * 排产人员 比较(gte)
   */
  private String productionSchedulingPersonnelGte;
  /**
   * 排产人员 比较(lt)
   */
  private String productionSchedulingPersonnelLt;
  /**
   * 排产人员 比较(lte)
   */
  private String productionSchedulingPersonnelLte;
  /**
   * 排产人员 比较(contains)
   */
  private String productionSchedulingPersonnelContains;
  /**
   * 排产人员 比较(notcontains)
   */
  private String productionSchedulingPersonnelNotcontains;
  /**
   * 排产人员 比较(startswith)
   */
  private String productionSchedulingPersonnelStartswith;
  /**
   * 排产人员 比较(endswith)
   */
  private String productionSchedulingPersonnelEndswith;
  /**
   * 排产人员 比较(isnull)
   */
  private Boolean productionSchedulingPersonnelIsnull;
  /**
   * 排产人员 比较(isnotnull)
   */
  private Boolean productionSchedulingPersonnelIsnotnull;

  /**
   * 排产人员(精确搜索)
   */
  private List<String> productionSchedulingPersonnelInList;

  /**
   * 生产人员(模糊搜索)
   */
  private String productionPersonnel;

  /**
   * 生产人员 比较(eq)
   */
  private String productionPersonnelEq;
  /**
   * 生产人员 比较(neq)
   */
  private String productionPersonnelNeq;
  /**
   * 生产人员 比较(gt)
   */
  private String productionPersonnelGt;
  /**
   * 生产人员 比较(gte)
   */
  private String productionPersonnelGte;
  /**
   * 生产人员 比较(lt)
   */
  private String productionPersonnelLt;
  /**
   * 生产人员 比较(lte)
   */
  private String productionPersonnelLte;
  /**
   * 生产人员 比较(contains)
   */
  private String productionPersonnelContains;
  /**
   * 生产人员 比较(notcontains)
   */
  private String productionPersonnelNotcontains;
  /**
   * 生产人员 比较(startswith)
   */
  private String productionPersonnelStartswith;
  /**
   * 生产人员 比较(endswith)
   */
  private String productionPersonnelEndswith;
  /**
   * 生产人员 比较(isnull)
   */
  private Boolean productionPersonnelIsnull;
  /**
   * 生产人员 比较(isnotnull)
   */
  private Boolean productionPersonnelIsnotnull;

  /**
   * 生产人员(精确搜索)
   */
  private List<String> productionPersonnelInList;

  /**
   * 财务行政人员(模糊搜索)
   */
  private String financialAdministrativePersonnel;

  /**
   * 财务行政人员 比较(eq)
   */
  private String financialAdministrativePersonnelEq;
  /**
   * 财务行政人员 比较(neq)
   */
  private String financialAdministrativePersonnelNeq;
  /**
   * 财务行政人员 比较(gt)
   */
  private String financialAdministrativePersonnelGt;
  /**
   * 财务行政人员 比较(gte)
   */
  private String financialAdministrativePersonnelGte;
  /**
   * 财务行政人员 比较(lt)
   */
  private String financialAdministrativePersonnelLt;
  /**
   * 财务行政人员 比较(lte)
   */
  private String financialAdministrativePersonnelLte;
  /**
   * 财务行政人员 比较(contains)
   */
  private String financialAdministrativePersonnelContains;
  /**
   * 财务行政人员 比较(notcontains)
   */
  private String financialAdministrativePersonnelNotcontains;
  /**
   * 财务行政人员 比较(startswith)
   */
  private String financialAdministrativePersonnelStartswith;
  /**
   * 财务行政人员 比较(endswith)
   */
  private String financialAdministrativePersonnelEndswith;
  /**
   * 财务行政人员 比较(isnull)
   */
  private Boolean financialAdministrativePersonnelIsnull;
  /**
   * 财务行政人员 比较(isnotnull)
   */
  private Boolean financialAdministrativePersonnelIsnotnull;

  /**
   * 财务行政人员(精确搜索)
   */
  private List<String> financialAdministrativePersonnelInList;

  /**
   * 加工制造能力(模糊搜索)
   */
  private String processManufacturingCapacity;

  /**
   * 加工制造能力 比较(eq)
   */
  private String processManufacturingCapacityEq;
  /**
   * 加工制造能力 比较(neq)
   */
  private String processManufacturingCapacityNeq;
  /**
   * 加工制造能力 比较(gt)
   */
  private String processManufacturingCapacityGt;
  /**
   * 加工制造能力 比较(gte)
   */
  private String processManufacturingCapacityGte;
  /**
   * 加工制造能力 比较(lt)
   */
  private String processManufacturingCapacityLt;
  /**
   * 加工制造能力 比较(lte)
   */
  private String processManufacturingCapacityLte;
  /**
   * 加工制造能力 比较(contains)
   */
  private String processManufacturingCapacityContains;
  /**
   * 加工制造能力 比较(notcontains)
   */
  private String processManufacturingCapacityNotcontains;
  /**
   * 加工制造能力 比较(startswith)
   */
  private String processManufacturingCapacityStartswith;
  /**
   * 加工制造能力 比较(endswith)
   */
  private String processManufacturingCapacityEndswith;
  /**
   * 加工制造能力 比较(isnull)
   */
  private Boolean processManufacturingCapacityIsnull;
  /**
   * 加工制造能力 比较(isnotnull)
   */
  private Boolean processManufacturingCapacityIsnotnull;

  /**
   * 加工制造能力(精确搜索)
   */
  private List<String> processManufacturingCapacityInList;

  /**
   * 固定资产(模糊搜索)
   */
  private String fixedAssets;

  /**
   * 固定资产 比较(eq)
   */
  private String fixedAssetsEq;
  /**
   * 固定资产 比较(neq)
   */
  private String fixedAssetsNeq;
  /**
   * 固定资产 比较(gt)
   */
  private String fixedAssetsGt;
  /**
   * 固定资产 比较(gte)
   */
  private String fixedAssetsGte;
  /**
   * 固定资产 比较(lt)
   */
  private String fixedAssetsLt;
  /**
   * 固定资产 比较(lte)
   */
  private String fixedAssetsLte;
  /**
   * 固定资产 比较(contains)
   */
  private String fixedAssetsContains;
  /**
   * 固定资产 比较(notcontains)
   */
  private String fixedAssetsNotcontains;
  /**
   * 固定资产 比较(startswith)
   */
  private String fixedAssetsStartswith;
  /**
   * 固定资产 比较(endswith)
   */
  private String fixedAssetsEndswith;
  /**
   * 固定资产 比较(isnull)
   */
  private Boolean fixedAssetsIsnull;
  /**
   * 固定资产 比较(isnotnull)
   */
  private Boolean fixedAssetsIsnotnull;

  /**
   * 固定资产(精确搜索)
   */
  private List<String> fixedAssetsInList;

  /**
   * 流动资金(模糊搜索)
   */
  private String currentAssets;

  /**
   * 流动资金 比较(eq)
   */
  private String currentAssetsEq;
  /**
   * 流动资金 比较(neq)
   */
  private String currentAssetsNeq;
  /**
   * 流动资金 比较(gt)
   */
  private String currentAssetsGt;
  /**
   * 流动资金 比较(gte)
   */
  private String currentAssetsGte;
  /**
   * 流动资金 比较(lt)
   */
  private String currentAssetsLt;
  /**
   * 流动资金 比较(lte)
   */
  private String currentAssetsLte;
  /**
   * 流动资金 比较(contains)
   */
  private String currentAssetsContains;
  /**
   * 流动资金 比较(notcontains)
   */
  private String currentAssetsNotcontains;
  /**
   * 流动资金 比较(startswith)
   */
  private String currentAssetsStartswith;
  /**
   * 流动资金 比较(endswith)
   */
  private String currentAssetsEndswith;
  /**
   * 流动资金 比较(isnull)
   */
  private Boolean currentAssetsIsnull;
  /**
   * 流动资金 比较(isnotnull)
   */
  private Boolean currentAssetsIsnotnull;

  /**
   * 流动资金(精确搜索)
   */
  private List<String> currentAssetsInList;

  /**
   * 应收应付账款(模糊搜索)
   */
  private String receivablePayableAccounts;

  /**
   * 应收应付账款 比较(eq)
   */
  private String receivablePayableAccountsEq;
  /**
   * 应收应付账款 比较(neq)
   */
  private String receivablePayableAccountsNeq;
  /**
   * 应收应付账款 比较(gt)
   */
  private String receivablePayableAccountsGt;
  /**
   * 应收应付账款 比较(gte)
   */
  private String receivablePayableAccountsGte;
  /**
   * 应收应付账款 比较(lt)
   */
  private String receivablePayableAccountsLt;
  /**
   * 应收应付账款 比较(lte)
   */
  private String receivablePayableAccountsLte;
  /**
   * 应收应付账款 比较(contains)
   */
  private String receivablePayableAccountsContains;
  /**
   * 应收应付账款 比较(notcontains)
   */
  private String receivablePayableAccountsNotcontains;
  /**
   * 应收应付账款 比较(startswith)
   */
  private String receivablePayableAccountsStartswith;
  /**
   * 应收应付账款 比较(endswith)
   */
  private String receivablePayableAccountsEndswith;
  /**
   * 应收应付账款 比较(isnull)
   */
  private Boolean receivablePayableAccountsIsnull;
  /**
   * 应收应付账款 比较(isnotnull)
   */
  private Boolean receivablePayableAccountsIsnotnull;

  /**
   * 应收应付账款(精确搜索)
   */
  private List<String> receivablePayableAccountsInList;

  /**
   * 库存情况(模糊搜索)
   */
  private String inventoryStatus;

  /**
   * 库存情况 比较(eq)
   */
  private String inventoryStatusEq;
  /**
   * 库存情况 比较(neq)
   */
  private String inventoryStatusNeq;
  /**
   * 库存情况 比较(gt)
   */
  private String inventoryStatusGt;
  /**
   * 库存情况 比较(gte)
   */
  private String inventoryStatusGte;
  /**
   * 库存情况 比较(lt)
   */
  private String inventoryStatusLt;
  /**
   * 库存情况 比较(lte)
   */
  private String inventoryStatusLte;
  /**
   * 库存情况 比较(contains)
   */
  private String inventoryStatusContains;
  /**
   * 库存情况 比较(notcontains)
   */
  private String inventoryStatusNotcontains;
  /**
   * 库存情况 比较(startswith)
   */
  private String inventoryStatusStartswith;
  /**
   * 库存情况 比较(endswith)
   */
  private String inventoryStatusEndswith;
  /**
   * 库存情况 比较(isnull)
   */
  private Boolean inventoryStatusIsnull;
  /**
   * 库存情况 比较(isnotnull)
   */
  private Boolean inventoryStatusIsnotnull;

  /**
   * 库存情况(精确搜索)
   */
  private List<String> inventoryStatusInList;

  /**
   * 企业(模糊搜索)
   */
  private String enterprise;

  /**
   * 企业 比较(eq)
   */
  private String enterpriseEq;
  /**
   * 企业 比较(neq)
   */
  private String enterpriseNeq;
  /**
   * 企业 比较(gt)
   */
  private String enterpriseGt;
  /**
   * 企业 比较(gte)
   */
  private String enterpriseGte;
  /**
   * 企业 比较(lt)
   */
  private String enterpriseLt;
  /**
   * 企业 比较(lte)
   */
  private String enterpriseLte;
  /**
   * 企业 比较(contains)
   */
  private String enterpriseContains;
  /**
   * 企业 比较(notcontains)
   */
  private String enterpriseNotcontains;
  /**
   * 企业 比较(startswith)
   */
  private String enterpriseStartswith;
  /**
   * 企业 比较(endswith)
   */
  private String enterpriseEndswith;
  /**
   * 企业 比较(isnull)
   */
  private Boolean enterpriseIsnull;
  /**
   * 企业 比较(isnotnull)
   */
  private Boolean enterpriseIsnotnull;

  /**
   * 企业(精确搜索)
   */
  private List<String> enterpriseInList;

  /**
   * 法人(模糊搜索)
   */
  private String legalPerson;

  /**
   * 法人 比较(eq)
   */
  private String legalPersonEq;
  /**
   * 法人 比较(neq)
   */
  private String legalPersonNeq;
  /**
   * 法人 比较(gt)
   */
  private String legalPersonGt;
  /**
   * 法人 比较(gte)
   */
  private String legalPersonGte;
  /**
   * 法人 比较(lt)
   */
  private String legalPersonLt;
  /**
   * 法人 比较(lte)
   */
  private String legalPersonLte;
  /**
   * 法人 比较(contains)
   */
  private String legalPersonContains;
  /**
   * 法人 比较(notcontains)
   */
  private String legalPersonNotcontains;
  /**
   * 法人 比较(startswith)
   */
  private String legalPersonStartswith;
  /**
   * 法人 比较(endswith)
   */
  private String legalPersonEndswith;
  /**
   * 法人 比较(isnull)
   */
  private Boolean legalPersonIsnull;
  /**
   * 法人 比较(isnotnull)
   */
  private Boolean legalPersonIsnotnull;

  /**
   * 法人(精确搜索)
   */
  private List<String> legalPersonInList;

  /**
   * 是否有 知识产权
   */
  private Boolean intellectualProperty;

  /**
   * 是否有 产品成本调查表
   */
  private Boolean productCostQuestionnaire;

  /**
   * 是否有 老板身份证复印件
   */
  private Boolean bossIDCopyCard;

  /**
   * 是否有 质量体系认证
   */
  private Boolean qualitySystemCertification;

  /**
   * 是否有 设备
   */
  private Boolean device;

  /**
   * 是否有 厂房
   */
  private Boolean workShop;

  /**
   * 是否有 现场图片
   */
  private Boolean livePictures;

  /**
   * 是否有 行业强制认证
   */
  private Boolean industryMandatoryCertification;

  /**
   * 是否有 营业执照
   */
  private Boolean businessLicense;

  /**
   * 是否有 巡场拍照
   */
  private Boolean patrolPhotography;

  /**
   * 是否有 合同模版
   */
  private Boolean contractTemplate;

  /**
   * 开发任务子表编号
   */
  private Long taskItemId;

  /**
   * 最小开发任务子表编号
   */
  private Long taskItemIdMin;

  /**
   * 最大开发任务子表编号
   */
  private Long taskItemIdMax;

  /**
   * 开发任务子表编号 比较(eq)
   */
  private Long taskItemIdEq;
  /**
   * 开发任务子表编号 比较(neq)
   */
  private Long taskItemIdNeq;
  /**
   * 开发任务子表编号 比较(gt)
   */
  private Long taskItemIdGt;
  /**
   * 开发任务子表编号 比较(gte)
   */
  private Long taskItemIdGte;
  /**
   * 开发任务子表编号 比较(lt)
   */
  private Long taskItemIdLt;
  /**
   * 开发任务子表编号 比较(lte)
   */
  private Long taskItemIdLte;
  /**
   * 开发任务子表编号 比较(contains)
   */
  private Long taskItemIdContains;
  /**
   * 开发任务子表编号 比较(notcontains)
   */
  private Long taskItemIdNotcontains;
  /**
   * 开发任务子表编号 比较(startswith)
   */
  private Long taskItemIdStartswith;
  /**
   * 开发任务子表编号 比较(endswith)
   */
  private Long taskItemIdEndswith;
  /**
   * 开发任务子表编号 比较(isnull)
   */
  private Boolean taskItemIdIsnull;
  /**
   * 开发任务子表编号 比较(isnotnull)
   */
  private Boolean taskItemIdIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
